import { Injectable } from '@nestjs/common'
@Injectable()
export class WorkbenthService {
  getSearchOptions() {
    const brand = [
      { label: '所有品牌', value: '' },
      { label: 'KFC', value: 'KFC' },
      { label: '星巴克', value: '星巴克' },
    ]

    const partition = [
      { label: '所有分区', value: '' },
      { label: '北京区', value: '北京区' },
      { label: '上海区', value: '上海区2' },
    ]

    const shop = [
      { label: '所有店铺', value: '' },
      { label: '店铺1', value: '店铺1' },
      { label: '店铺2', value: '店铺2' },
    ]

    const source = [
      { label: '所有来源', value: '' },
      { label: '美团', value: '美团' },
      { label: '饿了么', value: '饿了么' },
    ]

    return {
      brand,
      partition,
      shop,
      source,
    }
  }

  generateDays(days: string) {
    const daysArray = []
    const today = new Date()

    for (let i = -1; i <= Number(days) + 1; i++) {
      const date = new Date(today)
      date.setDate(today.getDate() - (i + 1))
      const day = `${date.getMonth() + 1}.${date.getDate()}`
      daysArray.push(day)
    }
    daysArray.reverse()
    return daysArray
  }

  /**
   * 计算订单统计数据
   *
   * @param timeRange - 时间范围字符串，例如 '7' 表示过去 7 天
   * @param orders - 订单数组
   * @return 包含实收金额、实付金额、订单数量、有效订单数量、人均消费金额、新客和老客数量的统计数据对象
   */
  calculateOrderStatistics(timeRange: string, orders: any) {
    const date = this.generateDays(timeRange)
    const totalPrices = date.map((d) => this.getTotalPriceByDate(d, orders))
    const totalOrderCount = orders.length
    const validOrders = orders.filter((order) => order.status === '已送达')
    const validOrderCount = validOrders.length
    const actualAmount = totalPrices.reduce((sum, price) => sum + price, 0)
    const actualPayAmount = orders.reduce(
      (sum, order) => sum + order.price - order.numsum,
      0,
    )
    const perCapitaConsumption = actualAmount / totalOrderCount
    const newCustomers = {}
    const oldCustomers = {}
    orders.forEach((order) => {
      if (order.seller) {
        if (newCustomers[order.customerName]) {
          oldCustomers[order.customerName] = true
        } else {
          newCustomers[order.customerName] = true
        }
      }
    })
    // 返回统计数据对象
    return {
      PaidInAmount: actualAmount,
      TotalPaid: actualPayAmount,
      SalesOrderNumber: totalOrderCount,
      PerCapitaConsumptionAmount: validOrderCount,
      validOrderNumber: perCapitaConsumption,
      NewCustomer: Object.keys(newCustomers).length,
      patron: Object.keys(oldCustomers).length,
    }
  }

  /**
   * 根据给定的日期字符串，计算某一天的总销售额
   *
   * @param dateStr - 日期字符串，格式为'YYYY-MM-DD'或'MM-DD'
   * @param arr - 包含销售记录的数组，每个元素必须包含 price 和 DealTime 属性
   * @return - 给定日期的总销售额
   */
  getTotalPriceByDate(dateStr, arr) {
    // 检查日期字符串是否包含破折号。如果没有，将当前年份附加到它的前面。
    const dateTimeStr = dateStr.includes('-')
      ? dateStr
      : `${new Date().getFullYear()}-${dateStr}`
    // 创建一个新的 Date 对象，其值是通过解析日期时间字符串来设置的。
    const targetDate = new Date(dateTimeStr)
    // 从目标日期对象中获取日数字。
    const targetDay = targetDate.getDate()
    // 从目标日期对象获取月数字，并加一以匹配人类的月份表示方式（从 1 开始）。
    const targetMonth = targetDate.getMonth() + 1
    // 从目标日期对象获取年数字。
    const targetYear = targetDate.getFullYear()

    // 初始化总价格为 0。
    let totalPrice = 0

    // 遍历订单数组。
    for (let i = 0; i < arr.length; i++) {
      // 为每个订单创建一个 Date 对象，其值设置为订单的日期字符串。
      const orderDate = new Date(arr[i].DealTime)
      // 从订单日期对象中获取日数字。
      const orderDay = orderDate.getDate()
      // 从订单日期对象获取月数字，并加一以匹配人类的月份表示方式（从 1 开始）。
      const orderMonth = orderDate.getMonth() + 1
      // 从订单日期对象获取年数字。
      const orderYear = orderDate.getFullYear()

      // 检查订单日期是否与目标日期匹配。
      if (
        targetYear === orderYear &&
        targetMonth === orderMonth &&
        targetDay === orderDay
      ) {
        // 如果订单日期匹配，增加订单的价格到总价格中。
        totalPrice += arr[i].price
      }
    }

    // 返回指定日期的总价格。
    return totalPrice
  }

  /**
   * 根据交易时间和来源计算百分比
   *
   * @param days - 回溯的天数
   * @param orders - 订单数组
   * @return 一个对象，包含每个来源的订单百分比
   */
  calculatePercentageByDealTimeAndSource(
    days: number,
    orders: any,
  ): { [key: string]: number } {
    const date = new Date()
    const endDate = new Date(
      date.getFullYear(),
      date.getMonth(),
      date.getDate(),
    )
    const startDate = new Date(endDate)
    startDate.setDate(startDate.getDate() - days)

    // 根据成交时间过滤订单
    const filteredOrders = orders.filter((order) => {
      const orderDate = new Date(order.DealTime)
      return (
        orderDate.getTime() >= startDate.getTime() &&
        orderDate.getTime() < endDate.getTime()
      )
    })
    //统计名字出现的次数
    const sellerCount = {}
    // Count the occurrences of each origin

    // 计算每个来源的出现次数
    const sourceCount: { [key: string]: number } = {}

    filteredOrders.forEach((order) => {
      if (order.origin in sourceCount) {
        sourceCount[order.origin]++
      } else {
        sourceCount[order.origin] = 1
      }
    })

    // 计算订单总数
    const totalCount = Object.values(sourceCount).reduce((a, b) => a + b, 0)

    // 计算每个来源的百分比
    const percentage: { [key: string]: number } = {}
    for (const [source, count] of Object.entries(sourceCount)) {
      percentage[source] = (count / totalCount) * 100
    }

    return percentage
  }

  /**
   * 根据交易时间和来源计算百分比
   *
   * @param days - 回溯的天数
   * @param orders - 订单数组
   * @return 一个对象，包含每个来源的订单百分比
   */
  calculatePricePercentageByDealTimeAndSource(
    days: number,
    orders: any[],
  ): { [key: string]: number } {
    const currentDate = new Date()
    const endDate = new Date(
      currentDate.getFullYear(),
      currentDate.getMonth(),
      currentDate.getDate(),
    )
    const startDate = new Date(endDate)
    startDate.setDate(startDate.getDate() - days)

    // 根据成交时间过滤订单
    const filteredOrders = orders.filter((order) => {
      const orderDate = new Date(order.DealTime)
      return (
        orderDate.getTime() >= startDate.getTime() &&
        orderDate.getTime() < endDate.getTime()
      )
    })

    // 为每个来源订单累加价格
    const priceSumByOrigin: { [key: string]: number } = {}
    filteredOrders.forEach((order) => {
      if (order.origin in priceSumByOrigin) {
        priceSumByOrigin[order.origin] += order.price
      } else {
        priceSumByOrigin[order.origin] = order.price
      }
    })

    // 计算所有来源的价格总和
    const totalPrices = Object.values(priceSumByOrigin).reduce(
      (a, b) => a + b,
      0,
    )

    // 计算每个来源的订单百分比
    const percentageByOrigin: { [key: string]: number } = {}
    for (const [origin, totalPrice] of Object.entries(priceSumByOrigin)) {
      percentageByOrigin[origin] = (totalPrice / totalPrices) * 100
    }

    return percentageByOrigin
  }
}
